Manipulação de Dados com Pandas e GeoPandas

# 1. Importar a biblioteca pandas
import pandas as pd  # "pd" é o apelido padrão

# 2. Ler o arquivo CSV e carregar os dados em um DataFrame
try:
    df_praias = pd.read_csv('arquivos/Pontos.csv')

    # 3. Explorar os dados que foram carregados
    print("--- As 5 primeiras linhas do nosso DataFrame ---")
    print(df_praias.head())  # .head() mostra as primeiras 5 linhas

    print("\n--- Informações sobre as colunas e os tipos de dados ---")
    print(df_praias.info())  # .info() resume a estrutura do DataFrame

except FileNotFoundError:
    print("Erro: O arquivo 'arquivos/Pontos.csv' não foi encontrado.")
    print("Certifique-se de que ele está na pasta 'arquivos/' do seu projeto.")

import pandas as pd

try:
    df_praias = pd.read_csv('arquivos/Pontos.csv')

    # a) Selecionar uma coluna específica (retorna uma Series)
    nomes_das_praias = df_praias['Praia']
    print("--- Nomes de todas as praias ---")
    print(nomes_das_praias)

    # b) Calcular estatísticas básicas de uma coluna numérica
    latitude_media = df_praias['Latitude'].mean()
    print(f"\n--- A latitude média é: {latitude_media:.4f} ---")

    # c) Filtrar o DataFrame pela Situação
    praias_ruins = df_praias[df_praias['Situação'] == 'Ruim']
    print("\n--- Praias com situação 'Ruim' ---")
    print(praias_ruins)

except FileNotFoundError:
    print("Erro: O arquivo 'arquivos/Pontos.csv' não foi encontrado.")

import geopandas as gpd

# Caminho para o arquivo .shp (extraído do ZIP do IBGE)
caminho_shapefile = 'arquivos/SC_Municipios_2022/SC_Municipios_2022.shp'

try:
    gdf_municipios = gpd.read_file(caminho_shapefile)

    print("--- As 5 primeiras linhas do nosso GeoDataFrame ---")
    print(gdf_municipios.head())

    print("\n--- Informações sobre o GeoDataFrame ---")
    gdf_municipios.info()
    # Repare na coluna "geometry", exclusiva dos GeoDataFrames

except Exception as e:
    print(f"Não foi possível ler o arquivo Shapefile: {e}")
    print("Verifique se o caminho está correto e se o arquivo não está corrompido.")

import geopandas as gpd
import matplotlib.pyplot as plt

caminho_shapefile = 'shapefiles/SC_Municipios_2022.shp'

try:
    # Carregar o shapefile usando GeoPandas
    gdf_municipios = gpd.read_file(caminho_shapefile)

    # Plotar o mapa simples
    gdf_municipios.plot()
    plt.title("Mapa Simples dos Municípios de SC")  # adicionar título
    plt.xlabel("Longitude")                         # adicionar rótulo ao eixo x
    plt.ylabel("Latitude")                          # adicionar rótulo ao eixo y
    plt.show()                                       # exibir o gráfico

except Exception as e:
    print(f"Ocorreu um erro ao plotar o mapa: {e}")

import geopandas as gpd
import pandas as pd
import matplotlib.pyplot as plt

caminho_municipios = 'shapefiles/SC_Municipios_2022.shp'
caminho_pontos = 'arquivos/Pontos.csv'

try:
    gdf_municipios = gpd.read_file(caminho_municipios)

    # Filtrar apenas Florianópolis e garantir que esteja em WGS84
    gdf_floripa = gdf_municipios[gdf_municipios['NM_MUN'] == 'Florianópolis']
    if gdf_floripa.empty:
        raise ValueError('Não há registros de Florianópolis na camada municipal.')
    gdf_floripa = gdf_floripa.to_crs('EPSG:4326')

    # Transformar o CSV em GeoDataFrame de pontos
    df_pontos = pd.read_csv(caminho_pontos)
    gdf_pontos = gpd.GeoDataFrame(
        df_pontos,
        geometry=gpd.points_from_xy(df_pontos['Longitude'], df_pontos['Latitude']),
        crs='EPSG:4326'
    )

    fig, ax = plt.subplots(figsize=(9, 8))
    gdf_floripa.plot(
        ax=ax,
        color='#bbf7d0',
        edgecolor='#047857',
        linewidth=0.8,
        label='Florianópolis'
    )

    gdf_pontos.plot(
        ax=ax,
        color='#dc2626',
        markersize=45,
        marker='o',
        label='Pontos monitorados',
        alpha=0.85
    )

    ax.set_title('Pontos de balneabilidade dentro de Florianópolis', fontsize=15, fontweight='bold')
    ax.set_xlabel('Longitude')
    ax.set_ylabel('Latitude')
    ax.legend()
    ax.set_aspect('equal')
    plt.show()

except Exception as e:
    print(f"Ocorreu um erro ao montar a figura: {e}")

import geopandas as gpd

caminho_shapefile = 'arquivos/SC_Municipios_2022/SC_Municipios_2022.shp'
caminho_saida_geojson = 'saidas/municipios_sc.geojson'

try:
    gdf_municipios = gpd.read_file(caminho_shapefile)
    gdf_municipios.to_file(caminho_saida_geojson, driver='GeoJSON')
    print(f"Arquivo GeoJSON salvo com sucesso em: {caminho_saida_geojson}")

except Exception as e:
    print(f"Ocorreu um erro durante o processo: {e}")

import geopandas as gpd

caminho_shapefile = 'shapefiles/SC_Municipios_2022.shp'

try:
    # Carregar o shapefile usando GeoPandas
    gdf_municipios = gpd.read_file(caminho_shapefile)
    gdf_utm = gdf_municipios  # ponto de partida caso o CRS já esteja correto

    # verificar se o CRS está definido
    if gdf_municipios.crs is None:
        # criar uma exceção caso o CRS não esteja definido
        raise ValueError("O GeoDataFrame não possui um CRS definido. Por favor, defina o CRS antes de reprojetar.")

    # Reprojetar para UTM (EPSG:31982) se o CRS atual for diferente
    elif gdf_municipios.crs.to_string() != "EPSG:31982":
        print("Reprojetando para UTM (EPSG:31982)...")
        gdf_utm = gdf_municipios.to_crs("EPSG:31982")

    # Conferir o resultado
    print("\n--- Geometrias após a conversão para UTM (coordenadas em metros) ---")
    print(gdf_utm.head()) # exibir as primeiras linhas do GeoDataFrame reprojetado

except Exception as e:
    print(f"Ocorreu um erro durante a reprojeção: {e}")

import geopandas as gpd
from pathlib import Path

crs_destino = 'EPSG:31982'  # SIRGAS 2000 / UTM 22S
destino_gpkg = Path('saidas/base_geoespacial.gpkg')

camadas = [
    {
        'origem': 'arquivos/SC_Municipios_2022/SC_Municipios_2022.shp',
        'layer': 'municipios_sc'
    },
    {
        'origem': 'arquivos/exemplos/areas_preservacao.shp',
        'layer': 'areas_preservacao'
    }
]

destino_gpkg.parent.mkdir(parents=True, exist_ok=True)

for item in camadas:
    origem = Path(item['origem'])
    layer = item['layer']

    try:
        gdf = gpd.read_file(origem)
        gdf_utm = gdf.to_crs(crs_destino)
        gdf_utm.to_file(destino_gpkg, layer=layer, driver='GPKG')
        print(f"✅ Camada '{layer}' exportada para {destino_gpkg.name} em {crs_destino}")
    except Exception as erro:
        print(f"⚠️ Não foi possível processar {origem.name}: {erro}")

Ponto,Leste(X),Norte(Y),Elevacao,Descricao
P01,754231.56,6941234.89,12.34,Poste
P02,754235.12,6941238.45,12.56,Meio-fio
P03,754240.03,6941242.18,12.61,Esquina

import pandas as pd
import geopandas as gpd

try:
    df = pd.read_csv('arquivos/levantamento_rtk.csv')

    geometria = gpd.points_from_xy(df['Leste(X)'], df['Norte(Y)'])
    gdf = gpd.GeoDataFrame(df, geometry=geometria, crs='EPSG:31982')

    print('GeoDataFrame criado com sucesso!')
    print(gdf.head())
    print(f'CRS informado: {gdf.crs}')

except FileNotFoundError:
    print('Arquivo levantamento_rtk.csv não encontrado. Verifique o caminho.')
except Exception as erro:
    print(f'Erro ao criar o GeoDataFrame: {erro}')

import pandas as pd
import geopandas as gpd
from shapely.geometry import Point

try:
    # 1. Criar GeoDataFrame das praias
    df_praias = pd.read_csv('arquivos/Pontos.csv')
    geometry_praias = [Point(xy) for xy in zip(df_praias['Longitude'], df_praias['Latitude'])]
    gdf_praias = gpd.GeoDataFrame(df_praias, geometry=geometry_praias, crs='EPSG:4326')

    # 2. Carregar shapefile dos municípios
    gdf_municipios = gpd.read_file('arquivos/SC_Municipios_2022/SC_Municipios_2022.shp')

    # 3. Realizar a junção espacial
    # Cada praia será associada ao município que a contém
    praias_com_municipio = gpd.sjoin(gdf_praias, gdf_municipios, how='left', predicate='within')

    print("--- Praias com informações do município ---")
    print(praias_com_municipio[['Praia', 'Situação', 'NM_MUN']].head())

    # 4. Análise: quantas praias por município?
    contagem_por_municipio = praias_com_municipio.groupby('NM_MUN').size()
    print(f"\n--- Praias por município ---")
    print(contagem_por_municipio)

    # 5. Análise: situação das praias por município
    situacao_por_municipio = praias_com_municipio.groupby(['NM_MUN', 'Situação']).size().unstack(fill_value=0)
    print(f"\n--- Situação das praias por município ---")
    print(situacao_por_municipio)

except Exception as e:
    print(f"Erro na junção espacial: {e}")

import pandas as pd
import geopandas as gpd
from shapely.geometry import Point
import matplotlib.pyplot as plt

try:
    # 1. Criar GeoDataFrame das praias
    df_praias = pd.read_csv('arquivos/Pontos.csv')
    geometry_praias = [Point(xy) for xy in zip(df_praias['Longitude'], df_praias['Latitude'])]
    gdf_praias = gpd.GeoDataFrame(df_praias, geometry=geometry_praias, crs='EPSG:4326')

    # 2. Reprojetar para um sistema em metros (necessário para buffers em metros)
    gdf_praias_utm = gdf_praias.to_crs('EPSG:31982')  # UTM Zone 22S

    # 3. Criar buffers de 500 metros ao redor de cada praia
    gdf_praias_utm['buffer_500m'] = gdf_praias_utm.geometry.buffer(500)

    # 4. Criar um novo GeoDataFrame só com os buffers
    gdf_buffers = gdf_praias_utm.copy()
    gdf_buffers['geometry'] = gdf_buffers['buffer_500m']
    gdf_buffers = gdf_buffers.drop('buffer_500m', axis=1)

    # 5. Reprojetar de volta para visualização
    gdf_praias_plot = gdf_praias_utm.to_crs('EPSG:4326')
    gdf_buffers_plot = gdf_buffers.to_crs('EPSG:4326')

    print(f"Criados {len(gdf_buffers)} buffers de 500m")
    
    # 6. Visualizar (opcional)
    fig, ax = plt.subplots(figsize=(12, 8))
    gdf_buffers_plot.plot(ax=ax, color='lightblue', alpha=0.5, label='Buffer 500m')
    gdf_praias_plot.plot(ax=ax, color='red', markersize=50, label='Praias')
    ax.set_title('Praias e suas áreas de influência (500m)')
    ax.legend()
    plt.show()

    # 7. Calcular área total dos buffers
    area_total_buffers = gdf_buffers.geometry.area.sum()
    print(f"Área total dos buffers: {area_total_buffers:.2f} m²")

except Exception as e:
    print(f"Erro ao criar buffers: {e}")

import geopandas as gpd
from shapely.geometry import Point

caminho_shapefile = 'arquivos/SC_Municipios_2022/SC_Municipios_2022.shp'

try:
    gdf_municipios = gpd.read_file(caminho_shapefile)

    # 1. Criar um ponto para o IFSC (longitude, latitude)
    ponto_ifsc = Point(-48.54235, -27.59397)

    # 2. Consulta espacial: qual município contém o ponto?
    municipio_ifsc = gdf_municipios[gdf_municipios.contains(ponto_ifsc)]

    # 3. Exibir o resultado
    if not municipio_ifsc.empty:
        nome_municipio = municipio_ifsc['NM_MUN'].iloc[0]
        print(f"O ponto do IFSC está localizado no município de: {nome_municipio}")
    else:
        print("Não foi encontrado nenhum município contendo o ponto especificado.")

except Exception as e:
    print(f"Ocorreu um erro durante a consulta espacial: {e}")